﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SanFranciscoModel.Curso;
using SanFranciscoModel.Intermedias;
using System.Data.SqlClient;
using SanFranciscoModel.Maestros;

namespace SanFranciscoModel.Alumno
{
    public class AlumnoManager
    {
        

        //Metodo para devolver una lista de TipoAlumno cargada
        public List<TipoAlumno> getTipoAlumnoAll()
        {
            List<TipoAlumno> TipoAlumnoList = new List<TipoAlumno>();
            TipoAlumnoDataContext db        = new TipoAlumnoDataContext();

            var objeto = from tipoalumno in db.TipoAlumnos
                             select tipoalumno;
            foreach (var tipo in objeto)
            {
                TipoAlumnoList.Add(tipo);
            }
            return TipoAlumnoList;
        }


        //Devuelve la fecha a cargar, en base al calendariolectivo, teniendo en cuenta lo ya cargado antes
        public DateTime getProximaFechaAsistenciaCargar(int idCurso)
        {
            List<AsistenciaAlumno> ListAsistenciaAlumno = new List<AsistenciaAlumno>();
            AsistenciaAlumnoDataContext db = new AsistenciaAlumnoDataContext();
            DateTime max = new DateTime();

            var objeto = from x in db.AsistenciaAlumnos
                         where x.idCurso == idCurso
                         select x;

            foreach (var aa in objeto)
            {
                if (aa.Fecha > max)
                    max = aa.Fecha;
            }


            //en max tengo la ultima fecha cargada, ahora tengo que obtener la proxima del calendario lectivo
            List<DateTime> ListCalendariolectivoTemp = MaestroManager.getAllCalendarioLectivo();
            List<DateTime> ListCalendariolectivo = ListCalendariolectivoTemp.OrderBy(p => p.Date).ToList(); 

            bool freno = false;
            foreach (DateTime dt in ListCalendariolectivo)
            {

                if (dt > max && freno==false)
                {
                    freno = true;
                    max = dt;
                }
            }
            return max;
        }

        public int getCantidadDeAlumnosEnCurso(int idCurso)
        {
            List<AlumnoXCurso> ListAlumnoXCurso = new List<AlumnoXCurso>();
            AlumnoXCursoDataContext db = new AlumnoXCursoDataContext();

            var objeto = from x in db.AlumnoXCursos
                         where x.idCurso ==idCurso
                         select x;
            foreach (var s in objeto)
            {
                ListAlumnoXCurso.Add(s);
            }
            return ListAlumnoXCurso.Count;
        }

        public List<AlumnoXMateriaXNota> getAlumnoXMateriaXNotaAllbyDNIAlumno(int DNI)
        {
            List<AlumnoXMateriaXNota> AlumnoXMateriaXNotaList = new List<AlumnoXMateriaXNota>();
            AlumnoXMateriaXNotaDataContext db = new AlumnoXMateriaXNotaDataContext();

            var objeto = from x in db.AlumnoXMateriaXNota
                         where x.DNIAlumno==DNI
                         select x;
            foreach (var tipo in objeto)
            {
                AlumnoXMateriaXNotaList.Add(tipo);
            }
            return AlumnoXMateriaXNotaList;
        }

        public AlumnoXMateriaXNota getAlumnoXMateriaXNota(int DNI, int idMateria, int idCurso, int idTipoNota)
        {
            AlumnoXMateriaXNota AlumnoXMateriaXNota = new AlumnoXMateriaXNota();
            AlumnoXMateriaXNotaDataContext db = new AlumnoXMateriaXNotaDataContext();

            var objeto = from x in db.AlumnoXMateriaXNota
                         where x.DNIAlumno == DNI
                         && x.idMateria==idMateria
                         && x.IdCurso==idCurso
                         && x.TipoNota==idTipoNota
                         select x;
            foreach (var tipo in objeto)
            {
                AlumnoXMateriaXNota=tipo;
            }
            return AlumnoXMateriaXNota;
        }

        public bool ExistetAlumnoXMateriaXNota(int DNI, int idMateria, int idCurso, int idTipoNota)
        {
            AlumnoXMateriaXNota AlumnoXMateriaXNota = new AlumnoXMateriaXNota();
            AlumnoXMateriaXNotaDataContext db = new AlumnoXMateriaXNotaDataContext();

            var objeto = from x in db.AlumnoXMateriaXNota
                         where x.DNIAlumno == DNI
                         && x.idMateria==idMateria
                         && x.IdCurso==idCurso
                         && x.TipoNota==idTipoNota
                         select x;
            foreach (var tipo in objeto)
            {
                return true;
            }
            return false;
        }
        

        public void guardarAlumno(Alumno alumno)
        {
            AlumnoDataContext db = new AlumnoDataContext();
            alumno.FechaAlta = DateTime.Now;

            try
            {
                db.Alumnos.InsertOnSubmit(alumno);
                db.SubmitChanges();
            }
            catch (Exception e)
            {
            }


        }

        public void guardarAlumnoXMateriaXNota(AlumnoXMateriaXNota amn)
        {
            AlumnoXMateriaXNotaDataContext db = new AlumnoXMateriaXNotaDataContext();
            AlumnoXMateriaXNota AlumnoXMateriaXNota = new AlumnoXMateriaXNota();

            //si ya existe registro modifico, sino guardo uno nuevo
            if (ExistetAlumnoXMateriaXNota(amn.DNIAlumno, amn.idMateria, amn.IdCurso, amn.TipoNota))
            {
                AlumnoXMateriaXNota = getAlumnoXMateriaXNota(amn.DNIAlumno, amn.idMateria, amn.IdCurso, amn.TipoNota);
                if (AlumnoXMateriaXNota.NotaConducta == null)
                    AlumnoXMateriaXNota.NotaConducta = amn.NotaConducta;
                else
                    AlumnoXMateriaXNota.NotaMateria = amn.NotaMateria;
                modificarAlumnoXMateriaXNota(AlumnoXMateriaXNota);
            }
            else
            {
                try
                {
                    db.AlumnoXMateriaXNota.InsertOnSubmit(amn);
                    db.SubmitChanges();
                }
                catch (Exception e)
                {
                }
            }
            
        }

        public void modificarAlumnoXMateriaXNota(AlumnoXMateriaXNota amn)
        {
            AlumnoXMateriaXNotaDataContext db = new AlumnoXMateriaXNotaDataContext();

            var objeto = from alum in db.AlumnoXMateriaXNota
                         where alum.DNIAlumno == amn.DNIAlumno
                         select alum;

            foreach (var al in objeto)
            {
                if (al.DNIAlumno == amn.DNIAlumno && al.IdCurso==amn.IdCurso && al.idMateria==amn.idMateria && al.TipoNota == amn.TipoNota)
                {
                    al.DNIAlumno = amn.DNIAlumno;
                    al.IdCurso = amn.IdCurso;
                    al.idMateria = amn.idMateria;
                    al.NotaConducta = amn.NotaConducta;
                    al.NotaMateria = amn.NotaMateria;
                    al.TipoNota = amn.TipoNota;
                }
            }

            try 
            {
                db.SubmitChanges();
            }
            catch (Exception e)
            {
                string ex = e.ToString();
                
            }
        }


        public Alumno getAlumnobyDNI(int DNI)
        {
            Alumno Alumno = new Alumno();
            AlumnoDataContext db = new AlumnoDataContext();

            var objeto = from alumno in db.Alumnos
                         where alumno.DNIAlumno == DNI
                         && alumno.Activo == true
                         select alumno;

            foreach (var alum in objeto)
            {
                Alumno = alum;
            }

            return Alumno;
        }

        public List<Alumno> getAlumnobyAll()
        {
            Alumno Alumno = new Alumno();
            AlumnoDataContext db = new AlumnoDataContext();
            List<Alumno> AlumnoList = new List<Alumno>();

            var objeto = from alumno in db.Alumnos
                         where alumno.Activo == true
                         select alumno;

            foreach (var alum in objeto)
            {
                AlumnoList.Add(alum);
            }

            return AlumnoList;
        }

        //Guarda en la tabla ConductaAlumno un registro
        public void guardarConductaAlumno(int dniAlumno, int idCurso, int nota, string aclaraciones)
        {
            ConductaAlumnoDataContext db = new ConductaAlumnoDataContext();
            ConductaAlumno ConductaAlumno = new ConductaAlumno();

            ConductaAlumno.DNIAlumno = dniAlumno;
            ConductaAlumno.idCurso = idCurso;
            ConductaAlumno.Nota = nota;
            ConductaAlumno.Aclaraciones = aclaraciones;

            try
            {
                db.ConductaAlumnos.InsertOnSubmit(ConductaAlumno);
                db.SubmitChanges();
            }
            catch (Exception e)
            {
            }
        }

        public void guardarInasistenciaAlumno(AsistenciaAlumno AsistenciaAlumno)
        {
            AsistenciaAlumnoDataContext db = new AsistenciaAlumnoDataContext();
            try
            {
                db.AsistenciaAlumnos.InsertOnSubmit(AsistenciaAlumno);
                db.SubmitChanges();
            }
            catch (Exception e)
            {
            }
        }


        public void modificarAlumno(Alumno alumno)
        {
            AlumnoDataContext db = new AlumnoDataContext();

            var objeto = from alum in db.Alumnos
                         where alumno.DNIAlumno == alumno.DNIAlumno
                         select alum;

            foreach (var al in objeto)
            {
                if (al.DNIAlumno == alumno.DNIAlumno)
                {
                    al.Nombre               = alumno.Nombre;
                    al.Apellido             = alumno.Apellido;
                    al.Direccion            = alumno.Direccion;
                    al.FechaNacimiento      = alumno.FechaNacimiento;
                    al.Nacionalidad         = alumno.Nacionalidad;
                    al.Sexo                 = alumno.Sexo;
                    al.Tipo                 = alumno.Tipo;
                }
            }

            try
            {
                db.SubmitChanges();
            }
            catch
            {
            }
        }

        

        public ConductaAlumno getConductaAlumnobyDNI(int DNI)
        {
            ConductaAlumno ConductaAlumno = new ConductaAlumno();
            ConductaAlumnoDataContext db = new ConductaAlumnoDataContext();

            var objeto = from alumno in db.ConductaAlumnos
                         where alumno.DNIAlumno == DNI
                         select alumno;

            foreach (var alum in objeto)
            {
                ConductaAlumno = alum;
            }

            return ConductaAlumno;
        }

        public bool ExisteAlumno(int DNI)
        {
            Alumno Alumno = new Alumno();
            AlumnoDataContext db = new AlumnoDataContext();

            var objeto = from alumno in db.Alumnos
                         where alumno.DNIAlumno == DNI
                         && alumno.Activo == true
                         select alumno;

            foreach (var alum in objeto)
            {
                Alumno = alum;
            }

            if (Alumno.DNIAlumno == DNI)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public bool ExisteConductaAlumnobyDNI(int DNI)
        {
            ConductaAlumno ConductaAlumno = new SanFranciscoModel.Alumno.ConductaAlumno();
            ConductaAlumnoDataContext db = new ConductaAlumnoDataContext();

            var objeto = from alumno in db.ConductaAlumnos
                         where alumno.DNIAlumno == DNI
                         select alumno;

            foreach (var alum in objeto)
            {
                ConductaAlumno = alum;
            }

            if (ConductaAlumno.DNIAlumno == DNI)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        //Si existe un dni alumno y un idCurso en una conductaAlumno devuelvo true, sino false
        public bool ExisteConductaAlumno(int DNI, int idCurso)
        {
            ConductaAlumno ConductaAlumno = new ConductaAlumno();

            ConductaAlumnoDataContext db = new ConductaAlumnoDataContext();

            var objeto = from alumnoxcurso in db.ConductaAlumnos
                         where (alumnoxcurso.DNIAlumno == DNI) && (alumnoxcurso.idCurso == idCurso)
                         select alumnoxcurso;

            foreach (var alum in objeto)
            {
                ConductaAlumno = alum;
            }
            if (ConductaAlumno.DNIAlumno == DNI)
            {
                return true;
            }
            else
            {
                return false;
            }

        }

        public bool EliminarAlumno(int dni)
        {
            Alumno Alumno = new Alumno();
            AlumnoDataContext db = new AlumnoDataContext();

            var objeto = from alumno in db.Alumnos
                         where alumno.DNIAlumno == dni
                         select alumno;

            foreach (var alum in objeto)
            {
                alum.Activo = false;//Le doy la baja logica
            }

            try
            {
                db.SubmitChanges();
                return true;
            }
            catch
            {
                return false;
            }
        }

        public static List<AsistenciaAlumno> getAsistenciaAlumnoByDNIAndIdCurso(int _DNI, int idCurso)
        {
            List<AsistenciaAlumno> AsistenciaAlumnoList = new List<AsistenciaAlumno>();


            AsistenciaAlumno AsistenciaAlumno = new AsistenciaAlumno();
            AsistenciaAlumnoDataContext db = new AsistenciaAlumnoDataContext();

            var objeto = from x in db.AsistenciaAlumnos
                         where x.DNIAlumno == _DNI
                         && x.idCurso==idCurso
                         select x;

            foreach (var alum in objeto)
            {
                AsistenciaAlumnoList.Add(alum);
            }

            return AsistenciaAlumnoList;
        }

        public static List<AlumnoXMateriaXNota> getAlumnoXMateriaXNotaListByDNI(int _DNI)
        {
            List<AlumnoXMateriaXNota> AlumnoXMateriaXNotaList = new List<AlumnoXMateriaXNota>();
            AlumnoXMateriaXNota AlumnoXMateriaXNota = new AlumnoXMateriaXNota();

            AlumnoXMateriaXNotaDataContext db = new AlumnoXMateriaXNotaDataContext();

            var objeto = from x in db.AlumnoXMateriaXNota
                         where x.DNIAlumno == _DNI
                         select x;

            foreach (var alum in objeto)
            {
                AlumnoXMateriaXNotaList.Add(alum);
            }

            return AlumnoXMateriaXNotaList;
        }

        public static List<Alumno> getAlumnosByIdCurso(int idCurso)
        {
            List<AlumnoXCurso> ListAlumnoXCurso = new List<AlumnoXCurso>();
            List<Alumno> ListAlumno = new List<Alumno>();
            AlumnoXCursoDataContext db = new AlumnoXCursoDataContext();

            var objeto = from x in db.AlumnoXCursos
                         where x.idCurso == idCurso
                         select x;

            foreach (var axc in objeto)
            {
                AlumnoManager am = new AlumnoManager();
                ListAlumno.Add(am.getAlumnobyDNI(axc.DNIAlumno));
            }

            return ListAlumno;
        }

        public static List<Alumno> getAlumnosIngresoOkByIdCurso(int idCurso, DateTime Fecha)
        {
            List<AlumnoXCurso> ListAlumnoXCurso = new List<AlumnoXCurso>();
            List<Alumno> ListAlumno = new List<Alumno>();
            AlumnoXCursoDataContext db = new AlumnoXCursoDataContext();

            var objeto = from x in db.AlumnoXCursos
                         where x.idCurso == idCurso
                         select x;

            foreach (var axc in objeto)
            {
                AlumnoManager am = new AlumnoManager();
                if(!YatieneCargadaAsistencia(axc.DNIAlumno, Fecha))
                ListAlumno.Add(am.getAlumnobyDNI(axc.DNIAlumno));
            }

            return ListAlumno;
        }

        public static bool YatieneCargadaAsistencia(int DNIAlumno, DateTime Fecha)
        {
            AsistenciaAlumno AsistenciaAlumno = new AsistenciaAlumno();
            AsistenciaAlumnoDataContext db = new AsistenciaAlumnoDataContext();

            var objeto = from x in db.AsistenciaAlumnos
                         where x.DNIAlumno == DNIAlumno
                         && x.Asistio == 3
                         && x.Fecha.Day == Fecha.Day
                         && x.Fecha.Month == Fecha.Month
                         && x.Fecha.Year == Fecha.Year
                         select x;
            bool flag = false;

            foreach (var axc in objeto)
            {
                flag = true;
            }
            return flag;
        }

        public void guardarAsistenciaAlumno(List<AsistenciaAlumno> ListAsistenciaAlumno)
        {
            AsistenciaAlumnoDataContext db = new AsistenciaAlumnoDataContext();
            try
            {
                foreach (AsistenciaAlumno aa in ListAsistenciaAlumno)
                {
                    db.AsistenciaAlumnos.InsertOnSubmit(aa);
                    db.SubmitChanges();
                }
            }
            catch (Exception e)
            {
            }
        }
    }
}
